package com.cskaoyan.javase.oop3._2inner._3local._2usecase;

/**
 * 局部内部类经常使用在以下两个场景中：
 *      1.方法需要返回一个对象，返回值类型是引用数据类型时。
 *      2.方法需要传入一个对象，形参数据类型是引用数据类型时。
 * 方法需要返回一个对象时，可以在方法的局部位置写一个 局部内部类 继承/实现外部的类/接口
 * 创建对象后作为返回值。这是因为方法的返回值可以是返回值类型的对象
 * 也可以是子类对象（当返回值类型是引用数据类型时）。
 *
 * 方法需要传入一个对象实参时，可以在调用方法的位置定义一个局部内部类 来继承/实现外部的类/接口，
 * 创建对象后作为方法的实参传入。
 * 这是因为方法的实参可以是形参类型的对象，也可以子类对象（当返回值类型是引用数据类型时）。
 *
 *
 * 使用局部内部类的优点：
 *      1.绝对对外界隐藏，封装。
 *      2.相比较于传统的定义类，然后创建对象，它相对更加简洁省事。
 *
 * 缺点：
 *      这个类是一次性的。
 *
 * 综上
 * 假如在局部位置需要一次性的使用某个对象
 * 可以使用局部内部类创建它
 * 但是如果多次在不同的方法中使用，使用局部内部类就得不偿失了。
 *
 * @since 14:49
 * @author wuguidong@cskaoyan.onaliyun.com
 */
public class Demo {
    public static void main(String[] args) {
        test(new A());
        test(new ASon());
        class ASon extends A {
            @Override
            public void method() {
                System.out.println("我是局部内部类的实现,我更加高级~~");
            }
        }
        test(new ASon());
        test(new BaseASon());
        class BaseASon extends BaseA {
            @Override
            public void method() {
                System.out.println("局部内部类实现的抽象类子类,我更加高级~~");
            }
        }
        test(new BaseASon());

    }

    public static void test(A a) {
        a.method();
    }

    public static void test(BaseA aa){
        aa.method();
    }

    public static IA test(){
        class IAImpl implements IA {
            @Override
            public int method(int a) {
                return 666;
            }
        }
        return new IAImpl();
    }
}

class ASon extends A {
    @Override
    public void method() {
        System.out.println("手写A的子类");
    }
}

class A {
    public void method() {
        System.out.println("我是普通类A的成员方法method");
    }
}
class BaseASon extends BaseA{
    @Override
    public void method() {
        System.out.println("手写抽象类实现");
    }
}
abstract class BaseA {
    public abstract void method();
}

interface IA {
    int method(int a);
}
